bas080

function next(current = []) {
  if (current.length === 0)
    return [1]

  if (current.length === 1)
    return [1, 1]

  return [1, ...nextIter(current), 1]
}

busypeoples

Making Impossible States Impossible in ReasonML

Introduction

If you have already seen Richard Feldman's talk entitled "Making Impossible States Impossible" or have read "Designing with types: Making illegal states unrepresentable" then you can skip the explanations and just head straight to the Reason examples.

This post is intended to display how to model your Reason Application to prevent creating impossible states. The benefits of being able to design a feature in this way include avoiding having to deal with complex test scenarios regarding defined business rules and a clear documentation of what is possible just by looking at the type definition. Long story short, let's see how this all works by implementing an example.

Requirements

ChrisPenner

{-# language DeriveFunctor #-}
{-# language DataKinds #-}
{-# language GADTs #-}
{-# language ViewPatterns #-}
{-# language TypeFamilies #-}
module Prog where

import Data.Function ((&))

-- | Either X, O, or Nothing

i-am-tom

const fl = require('fantasy-land')

//- Lazy holds a vaue in a thunk, effectively delaying
//- evaluation until required. This is useful when we're
//- in a situation with either very large data set or
//- cyclical data.

//@ make stack-safe.
//> type Lazy a = Unit -> a
function Lazy(run) {

lexi-lambda

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

module Language.HigherRank.Main
  ( Expr(..)
  , EVar(..)
  , Type(..)
  , TVar(..)
  , TEVar(..)
  , runInfer
  ) where

srdjan

100+ different js counter apps...

jaysoo

/*
 * Top level index.js
 */
let R = require('ramda')

global.trace = msg => R.tap(x => console.log(msg, x))

/*
 * ...
 *

DrBoolean

import {StateT} from 'fantasy-states'
import Task from 'data.task'
import {prop, compose, map, chain, merge, always} from 'ramda'

// Unfortunately Binary Gendered Baby Page
//==========================================

// data App a b c = App State a (Task b c)
const App = StateT(Task)
const {get, put, modify} = App;

DrBoolean

import State, {get, put, modify} from 'fantasy-states'
import {prop, compose, map, chain, merge, always} from 'ramda'


// Unfortunately Binary Gendered Baby Page
//==========================================

const babies = [{id: 2, name: 'Anjali', sex: 'F'}, {id: 3, name: 'Antonio', sex: 'M'}]

// isFemale :: Baby -> Bool

DrBoolean

const daggy = require('daggy');
const {foldMap} = require('pointfree-fantasy')
const {concat, toUpper, prop, identity, range, compose} = require('ramda');

// Contravariant functors usually have this shape F(a -> ConcreteType).
// In other words, some type holding a function which is parametric on its input, but not output.
// They don't always have that shape, but it's a good intuition
// Covariant functors are what we're used to, which are parametric in their output
//================================================================