joneshf

(define (intersect? a b)
  (parallel? (vector-product (get-direction a)
			     (get-direction b))
	     (vector-product (create-vector (- (get-point a)
					       (get-point b)))
			     (get-direction b))))

joneshf

"perfis":{
  "conservador":{
    "renda_fixa":{
      "percentuais":[70,65,60,55,50,45,40,35,30,25],
      "divisao":{
        "Renda Fixa Referenciado":100,
        "Renda Fixa Índice":0
      }
    },
    "multimercado":{

joneshf

:- module(booleans, [and/2, or/2]).

:- op(1000, xfy, and).
:- op(1000, xfy, or).

and(P, Q) :- P , Q.

or(P, Q) :- P ; Q.

joneshf

{-# LANGUAGE FlexibleInstances, FunctionalDependencies, UndecidableInstances #-}

newtype State s a = State (s -> (a, s))

instance Monad (State s) where

    return a = State $ \s -> (a, s)
    
    State st >>= f = State $ \s ->
        let

joneshf

acpi
acpid
alsa-utils
arch-install-scripts
autoconf
automake
bash
bc
bison
bzip2

joneshf

add3 = (x, y, z) -> x + y + z

add-three = (x, y, z) --> add3 x, y, z

"""
add3 1 2: #{add3 1 2}
add-three 1 2: #{add-three 1 2}
"""

joneshf

Terminology

1. "value" is any JavaScript value, including any which have the structures defined below.
2. "equivalent" is an appropriate definition of equivalence for the given value. The definition should ensure that the two values can be safely swapped out in a program that respects abstractions. For example:
   • Two lists are equivalent if they are equivalent at all indices.
   • Two plain old JavaScript objects, interpreted as dictionaries, are equivalent when they are equivalent for all keys.
   • Two promises are equivalent when they yield equivalent values.

• Two functions are equivalent if they yield equivalent outputs for equivalent inputs.

joneshf

{-# LANGUAGE NoImplicitPrelude #-}

module Simpler where

import Prelude (($), Eq, Show)

import Control.Monad
import Data.Foldable
import Data.Monoid

joneshf

take :: Int -> [a] -> [a]
take n _      | n <= 0 =  []
take _ []              =  []
take n (x:xs)          =  x : take (n-1) xs

repeat :: a -> [a]
repeat y = ys where ys = y : ys

take 3 (repeat 1) ~>
  -- This evaluates in order of the clauses of take

joneshf

/**
 * Provides a disjoint union of two types.
 * A Validation is either <code>Invalid</code> or it is <code>Valid</code>.
 */
public class Validation<Invalid, Valid> {

    private Invalid invalid = null;
    private Valid valid = null;

    // We use a private constructor to ensure that our invariant