jackfirth

#lang racket/base


(provide sdfn-register-id scalar-sdfn-register-id vec3-sdfn-register-id (struct-out sdfn-register))


(require syntax/parse)


(struct sdfn-register (size offset initial-values) #:transparent)

jackfirth

The Function Design Recipe

The function design recipe is a series of steps to follow when creating a function. The primary purpose of these steps is to help you think through the problem you're trying to solve. A secondary purpose is to make you write down explanations of what you're trying to do so that other programmers, especially programmers you ask for help, can understand your code.

In this article, we will be applying the function design recipe to the following example problem:

The state of Tax Land has created a three-stage sales tax to cope with its budget deficit. Inexpensive items, those costing less than $1,000, are not taxed. Luxury items, with a price of more than $10,000, are taxed at the rate of eight percent (8.00%). Everything in between comes with a five percent (5.00%) markup.

Design a function for a cash register that, given the price of an item, computes the sales tax.

jackfirth

#lang typed/racket

(define-type Vec2 (Vector Flonum Flonum))

(: mad (Flonum Flonum Flonum . -> . Flonum))
(define (mad a b c)
  (+ (* a b) c))

(: vec2-mad (Vec2 Vec2 Vec2 . -> . Vec2))
(define (vec2-mad a b c)

jackfirth

#lang racket/base


(require racket/contract/base)


(provide
 (contract-out
  [sequence-markup? predicate/c]
  [sequence-markup

jackfirth

#lang racket/base

(require racket/unsafe/ops)

(define s1 (string-append))
(define s2 (string-append))

(immutable? s1) ; false
(immutable? s2) ; false
(eq? s1 s2) ; true (!!!)

jackfirth

-- an asynchronous computation in the monad m that produces an a or dies with SomeException
Promise m a

immediatePromise : a -> Promise m a
immediatePromiseM : m a -> Promise m a
immediateFailedPromise : Exception e => e -> Promise m Void
immediateFailedPromiseM : Exception e => m e -> Promise m Void
unitPromise : Promise m Unit
then : Promise m a -> (a -> b) -> Promise m b
thenM : Promise m a -> (a -> m b) -> Promise m b

jackfirth

#lang racket/base

(require racket/list
         racket/match
         rebellion/base/option
         rebellion/collection/list
         rebellion/streaming/reducer
         rebellion/streaming/transducer
         rebellion/type/enum
         fancy-app)

jackfirth

#lang racket/base

; See the Racket Style Guide for details on why this file is organized the way
; it is: https://docs.racket-lang.org/style/Units_of_Code.html


; We have to import racket/contract/base first in order to use contract-out.
(require racket/contract/base)

jackfirth

;; This is a hypothetical syntax for defining rewrite rules that can be used to create custom optimizations and
;; refactoring suggestions. This example assumes there's some sort of geometry library that accepts angles in terms of
;; either degrees or radians using wrapper structs like `(struct degrees (value))` and `(struct radians (value))`. If
;; the wrapping is done right where the function is called, it allocates garbage that specialized degree-specific and
;; radian-specific functions wouldn't allocate. But we don't want to double the API surface, so we instead create inlining
;; rules that fire when the wrapping is done at the call site.

(define-rewrite-rule rotate-degrees-specialization
  @explanation{Using the @racket[rotate-degrees] function avoids allocating the intermediate @racket[degrees] value.}
  #:surface-as hidden-optimization

jackfirth

#lang racket

(require (for-syntax racket/sequence
                     racket/symbol
                     racket/syntax
                     rebellion/collection/vector
                     syntax/parse/class/struct-id)
         syntax/parse/define)

;@------------------------------------------------------------------------------