▁When ▁the ▁compiler ▁knows ▁the ▁exact ▁data ▁types ▁that ▁are ▁in ▁use ▁( which ▁is ▁necessary ▁for ▁static ▁ver ification , ▁either ▁through ▁declaration ▁or ▁inference ) ▁it ▁can ▁produce ▁optimized ▁machine ▁code . ▁Some ▁dynamically ▁typed ▁languages ▁such ▁as ▁Common ▁L isp ▁allow ▁optional ▁type ▁declarations ▁for ▁optimization ▁for ▁this ▁reason . ▁ ▁By ▁contrast , ▁dynamic ▁typing ▁may ▁allow ▁comp ilers ▁to ▁run ▁faster ▁and ▁interpre ters ▁to ▁dynamically ▁load ▁new ▁code , ▁because ▁changes ▁to ▁source ▁code ▁in ▁dynamically ▁typed ▁languages ▁may ▁result ▁in ▁less ▁checking ▁to ▁perform ▁and ▁less ▁code ▁to ▁revis it . ▁This ▁too ▁may ▁reduce ▁the ▁edit - compile - test - debug ▁cycle . ▁ ▁Stat ically ▁typed ▁languages ▁that ▁lack ▁type ▁inference ▁( such ▁as ▁C ▁and ▁Java ▁prior ▁to ▁version ▁ 1 0 ) ▁require ▁that ▁program mers ▁declare ▁the ▁types ▁that ▁a ▁method ▁or ▁function ▁must ▁use . ▁This ▁can ▁serve ▁as ▁added ▁program ▁documentation , ▁that ▁is ▁active ▁and ▁dynamic , ▁instead ▁of ▁static . ▁This ▁allows ▁a ▁compiler ▁to ▁prevent ▁it ▁from ▁dr ifting ▁out ▁of ▁synchron y , ▁and ▁from ▁being ▁ignored ▁by ▁program mers . ▁However , ▁a ▁language ▁can ▁be ▁stat ically ▁typed ▁without ▁requiring ▁type ▁declarations ▁( examples ▁include ▁H askell , ▁Scala , ▁O C aml , ▁F #, ▁and ▁to ▁a ▁less er ▁extent ▁C # ▁and ▁C ++ ), ▁so ▁explicit ▁type ▁declaration ▁is ▁not ▁a ▁necessary ▁requirement ▁for ▁static ▁typing ▁in ▁all ▁languages . ▁ ▁Dynamic ▁typing ▁allows ▁construct s ▁that ▁some