Refutable

4 definitions found

From The Collaborative International Dictionary of English v.0.48 [gcide]:

  Refutable \Re*fut"a*ble\ (r?*f?t"?*b'l;277), a. [Cf. F.
     r['e]futable.]
     Admitting of being refuted or disproved; capable of being
     proved false or erroneous.
     [1913 Webster]



From WordNet (r) 2.0 [wn]:

  refutable
       adj : able to be refuted [syn: {questionable}, {confutable}, {confutative}]

From Moby Thesaurus II by Grady Ward, 1.0 [moby-thes]:

  31 Moby Thesaurus words for "refutable":
     arguable, at issue, confutable, conjectural, contestable,
     controversial, controvertible, debatable, defeasible, deniable,
     disprovable, disputable, doubtable, doubtful, dubious, dubitable,
     iffy, in dispute, in doubt, in dubio, in question, mistakable,
     moot, open to doubt, open to question, problematic, questionable,
     speculative, suppositional, suspect, suspicious
  
  

From The Free On-line Dictionary of Computing (27 SEP 03) [foldoc]:

  refutable
       
          In lazy functional languages, a refutable pattern is one which
          may fail to match.  An expression being matched against a
          refutable pattern is first evaluated to head normal form
          (which may fail to terminate) and then the top-level
          constructor of the result is compared with that of the
          pattern.  If they are the same then any arguments are matched
          against the pattern's arguments otherwise the match fails.
       
          An irrefutable pattern is one which always matches.  An
          attempt to evaluate any variable in the pattern forces the
          pattern to be matched as though it were refutable which may
          fail to match (resulting in an error) or fail to terminate.
       
          Patterns in Haskell are normally refutable but may be made
          irrefutable by prefixing them with a tilde (~).  For example,
       
          	(\ (x,y) -> 1) undefined	==>	undefined
          	(\ ~(x,y) -> 1) undefined	==>	1
       
          Patterns in Miranda are refutable, except for tuples which are
          irrefutable.  Thus
       
          	g [x] = 2
          	g undefined			==>	undefined
       
          	f (x,y) = 1
          	f undefined			==>	1
       
          Pattern bindings in local definitions are irrefutable in both
          languages:
       
          	h = 1 where [x] = undefined	==>	1
          Irrefutable patterns can be used to simulate unlifted products
          because they effectively ignore the top-level constructor of
          the expression being matched and consider only its components.