How to use sanctuary-def - 10 common examples

const $ = require ('sanctuary-def');
const show = require ('sanctuary-show');
const Z = require ('sanctuary-type-classes');
const type = require ('sanctuary-type-identifiers');


//    Sum :: Number -> Sum
function Sum(value) {
  if (!(this instanceof Sum)) return new Sum (value);
  this.value = value;
}

Sum['@@type'] = 'sanctuary/Sum';

//    Type :: Type
Sum.Type = $.NullaryType
  (Sum['@@type'])
  ('')
  ([])
  (x => type (x) === Sum['@@type']);

Sum[FL.empty] = () => Sum (0);

Sum.prototype[FL.equals] = function(other) {
  return Z.equals (this.value, other.value);
};

Sum.prototype[FL.concat] = function(other) {
  return Sum (this.value + other.value);
};

Sum.prototype[FL.invert] = function() {

List.prototype.constructor = List;

function _List(tag, head, tail) {
  this.isCons = tag === 'Cons';
  this.isNil = tag === 'Nil';
  if (this.isCons) {
    this.head = head;
    this.tail = tail;
  }
}

List['@@type'] = 'sanctuary/List';

//    Type :: Type -> Type
List.Type = $.UnaryType
  (List['@@type'])
  ('')
  ([])
  (x => type (x) === List['@@type'])
  (list => list);

//    Nil :: List a
const Nil = List.Nil = new _List ('Nil');

//    Cons :: a -> List a -> List a
const Cons = List.Cons = function Cons(head) {
  eq (arguments.length) (Cons.length);
  return function Cons$1(tail) {
    eq (arguments.length) (Cons$1.length);
    return new _List ('Cons', head, tail);
  };

const Sum = require ('./Sum');


//    UnaryType :: String -> String -> Type
const UnaryType = name => typeIdent =>
  $.UnaryType (typeIdent)
              ('')
              ([])
              (x => type (x) === typeIdent)
              (v => [v.value])
              ($.Unknown);

//    env :: Array Type
const env = S.env.concat ([
  UnaryType ('Compose') ('sanctuary/Compose'),
  List.Type ($.Unknown),
  Sum.Type,
]);

module.exports = S.create ({checkTypes: true, env});

})

    console.log(SANCT);

    //    Integer :: Type
    const Integer = SANCT.NullaryType
      ('my-package/Integer')
      ('http://example.com/my-package#Integer')
      (x => typeof x === 'number' &&
            Math.floor (x) === x &&
            x >= Number.MIN_SAFE_INTEGER &&
            x <= Number.MAX_SAFE_INTEGER);

    window.def = HMD.create({
      checkTypes: true,
      env: SANCT.env.concat([Integer]),
    });

    // const sum = def(
    //   'sum :: Integer -> Integer -> Integer -> Integer',
    //   (a, b, c) => a + b + c
    // );

    // eval("const sum = def('sum :: Integer -> Integer -> Integer -> Integer',(a, b, c) => a + b + c);")

    $("head").append("");

    //sum(x, y, z)
    console.log('----', sum(5)(8)(14))

});

loop: false,
        slidesPerView: "auto",
        noSwiping: true,
        noSwipingClass: "no-swipe",

        // Navigation arrows
        navigation: {
        nextEl: '.swiper-button-next',
        prevEl: '.swiper-button-prev',
        }
    })

    console.log(SANCT);

    //    Integer :: Type
    const Integer = SANCT.NullaryType
      ('my-package/Integer')
      ('http://example.com/my-package#Integer')
      (x => typeof x === 'number' &&
            Math.floor (x) === x &&
            x >= Number.MIN_SAFE_INTEGER &&
            x <= Number.MAX_SAFE_INTEGER);

    window.def = HMD.create({
      checkTypes: true,
      env: SANCT.env.concat([Integer]),
    });

    // const sum = def(
    //   'sum :: Integer -> Integer -> Integer -> Integer',
    //   (a, b, c) => a + b + c
    // );

return S.isJust(result) ? S.Right(result.value) : S.Left(null)
    }
}

/**
 * Concats two strings
 * @return {Future}
 */
export const prepend = (a: string) => (b: string) => {
    const argsAreStrings = typeof a === 'string' && typeof b === 'string'

    return argsAreStrings ? Future.of(a + b) : Future.reject('Both args should be strings')
}

/* TYPE CHECKING UTILS */
export const isObject = S.is($.Object)

/* LOGGING UTILS */
export const l = x => {
    console.log('!!!!!!!', x)
    return x
}

// returns a future
export const lf = x => {
    console.log('-------', x)
    return Future.of(x)
}

import $ from 'sanctuary-def';
import Z from 'sanctuary-type-classes';
import Future from 'fluture';
import FutureTypes from 'fluture-sanctuary-types';

const S = Sanctuary.create ({
  checkTypes: process.env.NODE_ENV !== 'production',
  env: Sanctuary.env.concat (FutureTypes.env)
});

const def = $.create ({
  checkTypes: process.env.NODE_ENV !== 'production',
  env: $.env.concat (FutureTypes.env)
});

$.a = $.TypeVariable ('a');
$.b = $.TypeVariable ('b');
$.Either = S.EitherType;
$.Maybe = S.MaybeType;
$.Future = FutureTypes.FutureType;

// Extensions
S.chainRej = S.curry2 ((fn, future) => future.chainRej (fn));
S.replace = S.curry3((key, replacement, str) => str.replace (key, replacement));
S.lift4 = S.curry4 ((fn, a1, a2, a3, a4) => Z.ap (Z.ap (Z.ap (Z.map (fn, a1), a2), a3), a4));
S.eitherToFuture = S.either (Future.reject) (Future.of);
S.invoke = fnName => arg => obj => obj[fnName] (arg); 

export {
  $,
  S,
  def,

import Z from 'sanctuary-type-classes';
import Future from 'fluture';
import FutureTypes from 'fluture-sanctuary-types';

const S = Sanctuary.create ({
  checkTypes: process.env.NODE_ENV !== 'production',
  env: Sanctuary.env.concat (FutureTypes.env)
});

const def = $.create ({
  checkTypes: process.env.NODE_ENV !== 'production',
  env: $.env.concat (FutureTypes.env)
});

$.a = $.TypeVariable ('a');
$.b = $.TypeVariable ('b');
$.Either = S.EitherType;
$.Maybe = S.MaybeType;
$.Future = FutureTypes.FutureType;

// Extensions
S.chainRej = S.curry2 ((fn, future) => future.chainRej (fn));
S.replace = S.curry3((key, replacement, str) => str.replace (key, replacement));
S.lift4 = S.curry4 ((fn, a1, a2, a3, a4) => Z.ap (Z.ap (Z.ap (Z.map (fn, a1), a2), a3), a4));
S.eitherToFuture = S.either (Future.reject) (Future.of);
S.invoke = fnName => arg => obj => obj[fnName] (arg); 

export {
  $,
  S,
  def,
  Future

import Sanctuary from 'sanctuary';
import $ from 'sanctuary-def';
import Z from 'sanctuary-type-classes';
import Future from 'fluture';
import FutureTypes from 'fluture-sanctuary-types';

const S = Sanctuary.create ({
  checkTypes: process.env.NODE_ENV !== 'production',
  env: Sanctuary.env.concat (FutureTypes.env)
});

const def = $.create ({
  checkTypes: process.env.NODE_ENV !== 'production',
  env: $.env.concat (FutureTypes.env)
});

$.a = $.TypeVariable ('a');
$.b = $.TypeVariable ('b');
$.Either = S.EitherType;
$.Maybe = S.MaybeType;
$.Future = FutureTypes.FutureType;

// Extensions
S.chainRej = S.curry2 ((fn, future) => future.chainRej (fn));
S.replace = S.curry3((key, replacement, str) => str.replace (key, replacement));
S.lift4 = S.curry4 ((fn, a1, a2, a3, a4) => Z.ap (Z.ap (Z.ap (Z.map (fn, a1), a2), a3), a4));
S.eitherToFuture = S.either (Future.reject) (Future.of);
S.invoke = fnName => arg => obj => obj[fnName] (arg); 

export {

'use strict';

const FutureTypes   = require ('fluture-sanctuary-types');
const S             = require ('sanctuary');
const $             = require ('sanctuary-def');


//    PromiseType :: Type
const PromiseType = $.NullaryType
  ('Promise')
  ('')
  ([])
  (x => x != null && x.constructor === Promise);

module.exports = S.create ({
  checkTypes: true,
  env: S.env.concat (FutureTypes.env.concat ([PromiseType])),
});