martinsson

data Fizzbuzz : (k: Nat) -> Type where
  Fizz : (k: Nat) -> IsFizz k -> Not (IsBuzz k) -> Fizzbuzz k

martinsson

let card = deckOfCardsObject.getNextCard(someStep)

martinsson

cardIndex = cardIndex + someStep
if (cardIndex > cards.length) {
  cardIndex = 0
}
let card = cards[cardIndex]

// Use of a modulo would be simpler and less error-prone.

cardIndex = (cardIndex + someIndex) % deckOfCards.length
let card = deckOfCards[cardIndex]

martinsson

let foundAnimal
for (animal in animals) {
  if (animal.type === 'cat') {
    foundAnimal = animal
    break;
  }
}

martinsson

let isCat = animal => animal.type === 'cat'
let foundAnimal = animals.some(isCat)

martinsson

let foundAnimal 
let i = 0 
while (i <= animals.length && !foundAnimal) { 
  if (animals[i].type === 'cat') { 
    foundAnimal = animals[i] 
  } 
}

martinsson

// This function needs only one test
function hardToTest() {
	let data = requestExternalServer()
	let lang = persistence.get(data.id))

	let langToUpdate = makeLangToUpdate(lang)

	return persistence.update(data.id, langToUpdate)
}

martinsson

function hardToTest() {
	let data = requestExternalServer() // hard to test
	let lang = persistence.get(data.id)) // hard to test

	// below pure transformation logic
	let langToUpdate = {};
	versionsLangs.map((versionLang) => {
		let restPath = versionLang.entity.toRestPath();
	
		lang.dates.langsDates.map(datePayload => {

martinsson

function hardToTest() {
	let data = callToDependency()
	let result = easyToTestPureFunction(data)
	let dataOther = callToDependency2(result)
}

function easyToTestPureFunction(data) {
        //
	// pure logic
	// pure logic

martinsson

function hardToTest() {
	let data = callToDependency()
	//
	// pure logic
	// pure logic
	// pure logic
	//
	let dataOther = callToDependency2(result)
}