Displaying 1 to 20 from 23 results

cpp17_in_TTs - Descriptions of C++17 features, presented mostly in "Tony Tables" (hey, the name wasn't my idea)

  •    

Descriptions of C++17 features, presented mostly in "Tony Tables" (hey, the tables were my idea, but name wasn't). There are actually over 100 changes in C++17, only some of them are listed here.

Result - The modelling for success/failure of operations in Kotlin

  •    Kotlin

This is a tiny framework for modelling success/failure of operations in Kotlin. In short, it is a model in type of Result<V, E : Exception>. Result<V, E: Exception> is to provide higher abstraction of operation that can be ended with result either success or failure. The is somewhat similar to Kotlin's nullable types (T?) (https://kotlinlang.org/docs/reference/null-safety.html).

maybe - Maybe is a type that wraps optional values

  •    Javascript

Maybe is a type that wraps optional values. It can either be a Just (has some value) or a Nothing (has no value). In JavaScript, it is a better way of handling null and undefined. Instead of writing an if statement, ternary expression, or && shorthand to check if a value is present you can just map over it instead and assign the result of this expression or return it. You can also chain operations together, often leading to much cleaner code.




optional - Optional is a golang tool that generates 'optional' type wrappers as well as a library of Optional types

  •    Go

Optional is a tool that generates 'optional' type wrappers around a given type T. It is also a library that provides optional types for the primitive Go types.

squirrel - A furry little helper for dealing with optional NPM dependencies

  •    Javascript

Squirrel is a helpful node module that assists you requiring your dependencies for plugins of your application (version controlled via a custom pluginDependencies in your package.json file). Because personally, I really don't like the sitting waiting for a node package to install a whole swag of dependencies because it requires them for some functionality that I don't intend to use. I believe using squirrel will enable certain types of packages to have a leaner core with properly managed and installable optional dependencies.

monapt - Options, Tries, and Futures for JavaScript/TypeScript

  •    TypeScript

Monapt helps you better manage null, undefined, exceptions, and other mildly interesting phenomena. It handles them through the Option, Try, and Future abstractions. Docs are undergoing a redesign, and will be published on a separate site. In the meantime, the sources for the Option, Future, and Try classes are readable.

scelta - (experimental) Syntactic sugar for variant and optional types.

  •    C++

C++17 zero-overhead syntactic sugar for variant and optional. std::variant and std::optional were introduced to C++17's Standard Library. They are sum types that can greatly improve type safety and performance.


SafeCollection - Safe Collection for Swift

  •    Swift

SafeCollection provides a safer way to deal with subscripts. Inspired by Swift's LazyCollection. SafeCollection is under MIT license. See the LICENSE file for more info.

node-optional - NodeJS module to let you optionally include modules (instead of 'require')

  •    Javascript

Node-optional allows you to optionally 'require' modules without surrounding everything with 'try/catch'. Usage and installation is easy and this module itself is very easy and straightforward to use.

ts-option

  •    TypeScript

Scala like Option type for TypeScript/JavaScript. Create an Option instance from a value. It returns Some<A> when the value is not null/undefined, otherwise returns None.

browserify-optional - A browserify transform that allows optional dependencies in try..catch blocks

  •    Javascript

It is a common pattern in Node to support optional dependencies via requires in try..catch blocks. Browserify doesn't support this by default and throws a compile time error when it cannot find a module. You can solve the problem by using browserify's exclude option, but this works globally instead of at a per-module level. This transform fixes the problem by moving the compile time error to a runtime error for requires of missing modules inside try..catch blocks. The transform would transform the following code such that requiring missing-module would throw a runtime error instead of a compile time error, making the code work as expected.

react-nav-tabs - Generic, flexible tabbed based navigation with optional react-router support

  •    Javascript

A set of components making tabbed navigation easier. Optionally supports react-router if you'd like the tab panes to show routes instead of predefined components. The main goal of this project is to provide flexible class names, elements, and react-router in a concise way.

tsoption - Correct, easy to use Option type for TypeScript. πŸ¦„

  •    TypeScript

Correct, easy to use Option type for TypeScript. Like Scala options; see the introductory blog post. Note: You can use JavaScript instead of TypeScript, but it's not as fun.

optional-lite - A single-file header-only version of a C++17-like optional, a nullable object for C++98, C++11 and later

  •    C++

optional lite is a single-file header-only library to represent optional (nullable) objects and pass them by value. The library aims to provide a C++17-like optional for use with C++98 and later. If available, std::optional is used. There's also a simpler version, optional bare. Unlike optional lite, optional bare is limited to default-constructible and copyable types. Features and properties of optional lite are ease of installation (single header), freedom of dependencies other than the standard library and control over object alignment (if needed). optional lite shares the approach to in-place tags with any-lite, expected-lite and with variant-lite and these libraries can be used together.

value-ptr-lite - A C++ smart-pointer with value semantics for C++98, C++11 and later

  •    C++

value-ptr lite is a single-file header-only library to bring value semantics to heap resources. In certain situations, such as with the pimpl idiom in the example above, a pointer must be used while value semantics would be prefered. This is where value_ptr comes into play. A value_ptr is similar to a std::optional in many respects and one could say a value_ptr is more value than pointer. This work is inspired on value_ptr by Gaetano Checinski [1] and on impl_ptr by Andrey Upadyshev [2].

maybe - An Exception-Free Optional Type for Nim

  •    Nim

Note: There is a chance the main macro(maybeCase) may get merged into the standard library. If this happens I'll recommend people use that, but will accept bugfixes and reports on this library going forward, just no new features. An implementation of a maybe type, also known as option(al) in other languages.