clohr

class Node {
  constructor(data) {
    this.data = data
    this.next = null
  }
}
 
class SinglyList {
  constructor() {
    this._length = 0;

clohr

const count = names => names.reduce((acc, name) => Object.assign(acc, {[name]: (acc[name] || 0) + 1}), {})

const duplicates = dict => Object.keys(dict).filter((a) => dict[a] > 1)

const getDuplicates = vals => duplicates(count(vals))

export default getDuplicates

clohr

class Queue {
  constructor() {
    this._oldestIndex = 1
    this._newestIndex = 1
    this._storage = {}
  }
 getStorage() {
   return this._storage
 }
 getSize() {

clohr

class Stack {
  constructor() {
    this._size = 0
    this._storage = {}
  }
  getSize() {
    return this._size
  }
  getStorage() {
    return this._storage

clohr

const a = new Set([1, 2, 3, 4, 4, 4])
const b = new Set([3, 4, 5, 6])

const intersect = (set1, set2) => [...set1].filter(num => set2.has(num))
const differ = (set1, set2) => [...set1].filter(num => !set2.has(num))
const joinSet = (set1, set2) => [...set1, ...set2]

const myIntersectedSet = new Set(intersect(a, b))
console.log('myIntersectedSet', myIntersectedSet)

clohr

// fmap
precedencegroup ComparisonPrecedence {
    associativity: left
}

infix operator <^> : ComparisonPrecedence

func <^><A, B>(f: (A) -> B, a: A?) -> B? {
    switch a {
    case .some(let x):

clohr

const head = ([h, ...tail]) => h

const defaultTo = (defaultValue, testValue) => Boolean(testValue) ? testValue : defaultValue

const capture = (evt) => {
  const eventTarget = evt.target
  const touchTarget = evt.touches && evt.touches.length > 0
  
  const xPos = touchTarget ? head(touchTarget).clientX : evt.clientX
  const yPos = touchTarget ? head(touchTarget).clientY : evt.clientY

clohr

module Main exposing (..)

import Html exposing (..)
import Html.Attributes exposing (..)
import Html.Events exposing (onInput)


main =
    program
        { init = init

clohr

import Html exposing (..)
import Html.Attributes exposing (..)
import Html.Events exposing (onInput)
import Array exposing (Array)

main =
  program 
  {
    init = init, 
    update = update,

clohr

// Either
const Right = x => ({
  map: fn => Right(fn(x)),
  fold: (f, g) => g(x),
  inspect: () => `Right(${x})`
})

const Left = x => ({
  map: fn => Left(x),
  fold: (f, g) => f(x),