| /* Graph */ | |
| exception Not_found; | |
| type nodes = list(int); | |
| type edges = list((int, int)); | |
| type graph = | |
| | Empty | |
| | Graph(nodes, edges); |
| /* Heap */ | |
| exception Not_Found; | |
| module type Ord = {type t; let compare: (t, t) => int;}; | |
| module Integer = { | |
| type t = int; | |
| let compare = (a, b) => a - b; | |
| }; |
| /* AVL Tree */ | |
| /* A balanced Binary Search Tree */ | |
| exception Undefined; | |
| module type AvlTree = { | |
| type t = int; | |
| type height = int; | |
| type tree('t) = | |
| | Leaf | |
| | Node(height, tree('t), 't, tree('t)); |
| exception Empty_list; | |
| module type LinkedList = { | |
| type t; | |
| type linkedList('t) = | |
| | Empty | |
| | List('t, linkedList('t)); | |
| let empty: linkedList('t); | |
| let head: linkedList('t) => 't; | |
| let tail: linkedList('t) => linkedList('t); |
| /* Set */ | |
| /* Contains unique elements */ | |
| module type Ord = { | |
| type t; | |
| let eq: (t, t) => bool; | |
| let lt: (t, t) => bool; | |
| let leq: (t, t) => bool; | |
| }; | |
| module Integer: Ord with type t = int = { |
| /* Stack */ | |
| /* LIFO: Last In First Out*/ | |
| exception Empty; | |
| module type Stack = { | |
| type stack('a) = list('a); | |
| let create: unit => stack('a); | |
| let push: ('a, stack('a)) => stack('a); | |
| let pop: stack('a) => stack('a); | |
| let peak: stack('a) => 'a; |
| /* Binary Search Tree*/ | |
| /* Rules: | |
| 1. Values from the left node are smaller than the node's own value | |
| 2. Values from the right node are larger than the node's own value | |
| // Example | |
| // [] Node | |
| // () leaf | |
| [7] | |
| / \ | |
| [4] [9] |
| // @flow | |
| // Immutable Data Implementation | |
| // Based on Hash Tries | |
| // (NOTE: The actual implementation is based on hashed mapped tries!) | |
| // But this can be seen as a basis for the actual implementation. | |
| // This is only for learning purposes! | |
| // Hash Trie or Hash Tree is a persistent data structure, commonly used | |
| // to implement immuable maps. |
| // @flow | |
| /** | |
| * | |
| * Trie Example | |
| * This is part of a series of examples that will lead to implemeting | |
| * a hashed mapped trie based immutable data structure. | |
| * | |
| */ |
Transforming elements can be interesting if you're a library author, but can also be very valuable when writing components to abstract behaviour in your existing code base.
To get a better understanding, we will walkthrough the most important React Top Level API transformation functionalities. React offers a couple of helper functions that we can leverage when for creating and adapting elements, further information is available via the official React documentation.