Skip to content

Instantly share code, notes, and snippets.

Jon Bodner jonbodner

Block or report user

Report or block jonbodner

Hide content and notifications from this user.

Learn more about blocking users

Contact Support about this user’s behavior.

Learn more about reporting abuse

Report abuse
View GitHub Profile
View code_coverage_3.java
package com.example.demo.controller;
import com.example.demo.calculator.Calculator;
import com.example.demo.calculator.CalculatorException;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class CalcController {
View code_coverage_2.java
package com.example.demo.calculator;
import java.util.ArrayDeque;
import java.util.Deque;
public class CalculatorImpl implements Calculator {
public CalculatorImpl() {
}
@Override
View code_coverage_1.java
package com.example.demo.calculator;
public interface Calculator {
double process(String expression);
}
@jonbodner
jonbodner / silly_fizzbuzz.go
Created Sep 14, 2018
FizzBuzz without if statements
View silly_fizzbuzz.go
package main
import (
"fmt"
"strconv"
)
func main() {
vals := [][]string{{"FizzBuzz", "Fizz"}, {"Buzz", ""}}
for i := 1; i <= 100; i++ {
View workpool.go
type WorkPool struct {
work chan Runnable
shutdown chan struct{}
o sync.Once
}
type Runnable func()
func NewWorkPool(tasks int) *WorkPool {
work := make(chan Runnable, tasks)
View reflection2_9.go
func AddSlowly(a, b int) int {
time.Sleep(100 * time.Millisecond)
return a + b
}
func main() {
ch, err := Cacher(AddSlowly, 2*time.Second)
if err != nil {
panic(err)
}
View reflection2_8.go
type outExp struct {
out []reflect.Value
expiry time.Time
}
func Cacher(f interface{}, expiration time.Duration) (interface{}, error) {
ft := reflect.TypeOf(f)
if ft.Kind() != reflect.Func {
return nil, errors.New("Only for functions")
}
View reflection2_7.go
func buildInStruct(ft reflect.Type) (reflect.Type, error) {
if ft.NumIn() == 0 {
return nil, errors.New("Must have at least one param")
}
var sf []reflect.StructField
for i := 0; i < ft.NumIn(); i++ {
ct := ft.In(i)
if !ct.Comparable() {
return nil, fmt.Errorf("parameter %d of type %s and kind %v is not comparable", i+1, ct.Name(), ct.Kind())
}
View reflection2_6.go
func Cacher(f interface{}, expiration time.Duration) (interface{}, error) {
ft := reflect.TypeOf(f)
if ft.Kind() != reflect.Func {
return nil, errors.New("Only for functions")
}
return f, nil
}
View reflection2_5.go
// Takes in a function and a time.Duration and returns a caching version of the function
//
// The limitations on memoization are:
//
// — there must be at least one in parameter
//
// — there must be at least one out parameter
//
// — the in parameters must be comparable. That means they cannot be of kind slice, map, or func,
// nor can input parameters be structs that contain (at any level) slices, maps, or funcs.
You can’t perform that action at this time.